<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * Pure-PHP PKCS#1 (v2.1) compliant implementation of RSA.
 *
 * PHP versions 4 and 5
 *
 * Here's an example of how to encrypt and decrypt text with this library:
 * <code>
 * <?php
 *    include('Crypt/RSA.php');
 *
 *    $rsa = new Crypt_RSA();
 *    extract($rsa->createKey());
 *
 *    $plaintext = 'terrafrost';
 *
 *    $rsa->loadKey($privatekey);
 *    $ciphertext = $rsa->encrypt($plaintext);
 *
 *    $rsa->loadKey($publickey);
 *    echo $rsa->decrypt($ciphertext);
 * ?>
 * </code>
 *
 * Here's an example of how to create signatures and verify signatures with this library:
 * <code>
 * <?php
 *    include('Crypt/RSA.php');
 *
 *    $rsa = new Crypt_RSA();
 *    extract($rsa->createKey());
 *
 *    $plaintext = 'terrafrost';
 *
 *    $rsa->loadKey($privatekey);
 *    $signature = $rsa->sign($plaintext);
 *
 *    $rsa->loadKey($publickey);
 *    echo $rsa->verify($plaintext, $signature) ? 'verified' : 'unverified';
 * ?>
 * </code>
 *
 * LICENSE: This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA  02111-1307  USA
 *
 * @category   Crypt
 * @package    Crypt_RSA
 * @author     Jim Wigginton <terrafrost@php.net>
 * @copyright  MMIX Jim Wigginton
 * @license    http://www.gnu.org/licenses/lgpl.txt
 * @version    $Id: RSA.php,v 1.3 2009/12/04 21:05:32 terrafrost Exp $
 * @link       http://phpseclib.sourceforge.net
 */

if ( !defined(‘ROOT_PATH’) ) {
	define("ROOT_PATH", substr(dirname(__FILE__), 0, -6) );
}

/**
 * Include Math_BigInteger
 */
require_once(ROOT_PATH.'crypto/BigInteger.php');

/**
 * Include Crypt_Random
 */
require_once(ROOT_PATH.'crypto/Random.php');

/**
 * Include Crypt_Hash
 */
require_once(ROOT_PATH.'crypto/Hash.php');

/**#@+
 * @access public
 * @see Crypt_RSA::encrypt()
 * @see Crypt_RSA::decrypt()
 */
/**
 * Use {@link http://en.wikipedia.org/wiki/Optimal_Asymmetric_Encryption_Padding Optimal Asymmetric Encryption Padding}
 * (OAEP) for encryption / decryption.
 *
 * Uses sha1 by default.
 *
 * @see Crypt_RSA::setHash()
 * @see Crypt_RSA::setMGFHash()
 */
define('CRYPT_RSA_ENCRYPTION_OAEP',  1);
/**
 * Use PKCS#1 padding.
 *
 * Although CRYPT_RSA_ENCRYPTION_OAEP offers more security, including PKCS#1 padding is necessary for purposes of backwards
 * compatability with protocols (like SSH-1) written before OAEP's introduction.
 */
define('CRYPT_RSA_ENCRYPTION_PKCS1', 2);
/**#@-*/

/**#@+
 * @access public
 * @see Crypt_RSA::sign()
 * @see Crypt_RSA::verify()
 * @see Crypt_RSA::setHash()
 */
/**
 * Use the Probabilistic Signature Scheme for signing
 *
 * Uses sha1 by default.
 *
 * @see Crypt_RSA::setSaltLength()
 * @see Crypt_RSA::setMGFHash()
 */
define('CRYPT_RSA_SIGNATURE_PSS',  1);
/**
 * Use the PKCS#1 scheme by default.
 *
 * Although CRYPT_RSA_SIGNATURE_PSS offers more security, including PKCS#1 signing is necessary for purposes of backwards
 * compatability with protocols (like SSH-2) written before PSS's introduction.
 */
define('CRYPT_RSA_SIGNATURE_PKCS1', 2);
/**#@-*/

/**#@+
 * @access private
 * @see Crypt_RSA::createKey()
 */
/**
 * ASN1 Integer
 */
define('CRYPT_RSA_ASN1_INTEGER',   2);
/**
 * ASN1 Sequence (with the constucted bit set)
 */
define('CRYPT_RSA_ASN1_SEQUENCE', 48);
/**#@-*/

/**#@+
 * @access private
 * @see Crypt_RSA::Crypt_RSA()
 */
/**
 * To use the pure-PHP implementation
 */
define('CRYPT_RSA_MODE_INTERNAL', 1);
/**
 * To use the OpenSSL library
 *
 * (if enabled; otherwise, the internal implementation will be used)
 */
define('CRYPT_RSA_MODE_OPENSSL', 2);
/**#@-*/

/**#@+
 * @access public
 * @see Crypt_RSA::createKey()
 * @see Crypt_RSA::setPrivateKeyFormat()
 */
/**
 * PKCS#1 formatted private key
 *
 * Used by OpenSSH
 */
define('CRYPT_RSA_PRIVATE_FORMAT_PKCS1', 0);
/**#@-*/

/**#@+
 * @access public
 * @see Crypt_RSA::createKey()
 * @see Crypt_RSA::setPublicKeyFormat()
 */
/**
 * Raw public key
 *
 * An array containing two Math_BigInteger objects.
 *
 * The exponent can be indexed with any of the following:
 *
 * 0, e, exponent, publicExponent
 *
 * The modulus can be indexed with any of the following:
 *
 * 1, n, modulo, modulus
 */
define('CRYPT_RSA_PUBLIC_FORMAT_RAW', 1);
/**
 * PKCS#1 formatted public key
 */
define('CRYPT_RSA_PUBLIC_FORMAT_PKCS1', 2);
/**
 * OpenSSH formatted public key
 *
 * Place in $HOME/.ssh/authorized_keys
 */
define('CRYPT_RSA_PUBLIC_FORMAT_OPENSSH', 3);
/**#@-*/

/**
 * Pure-PHP PKCS#1 compliant implementation of RSA.
 *
 * @author  Jim Wigginton <terrafrost@php.net>
 * @version 0.1.0
 * @access  public
 * @package Crypt_RSA
 */
class Crypt_RSA {
	/**
	 * Precomputed Zero
	 *
	 * @var Array
	 * @access private
	 */
	var $zero;

	/**
	 * Precomputed One
	 *
	 * @var Array
	 * @access private
	 */
	var $one;

	/**
	 * Private Key Format
	 *
	 * @var Integer
	 * @access private
	 */
	var $privateKeyFormat = CRYPT_RSA_PRIVATE_FORMAT_PKCS1;

	/**
	 * Public Key Format
	 *
	 * @var Integer
	 * @access public
	 */
	var $publicKeyFormat = CRYPT_RSA_PUBLIC_FORMAT_PKCS1;

	/**
	 * Modulus (ie. n)
	 *
	 * @var Math_BigInteger
	 * @access private
	 */
	var $modulus;

	/**
	 * Modulus length
	 *
	 * @var Math_BigInteger
	 * @access private
	 */
	var $k;

	/**
	 * Exponent (ie. e or d)
	 *
	 * @var Math_BigInteger
	 * @access private
	 */
	var $exponent;

	/**
	 * Primes for Chinese Remainder Theorem (ie. p and q)
	 *
	 * @var Array
	 * @access private
	 */
	var $primes;

	/**
	 * Exponents for Chinese Remainder Theorem (ie. dP and dQ)
	 *
	 * @var Array
	 * @access private
	 */
	var $exponents;

	/**
	 * Coefficients for Chinese Remainder Theorem (ie. qInv)
	 *
	 * @var Array
	 * @access private
	 */
	var $coefficients;

	/**
	 * Hash name
	 *
	 * @var String
	 * @access private
	 */
	var $hashName;

	/**
	 * Hash function
	 *
	 * @var Crypt_Hash
	 * @access private
	 */
	var $hash;

	/**
	 * Length of hash function output
	 *
	 * @var Integer
	 * @access private
	 */
	var $hLen;

	/**
	 * Length of salt
	 *
	 * @var Integer
	 * @access private
	 */
	var $sLen;

	/**
	 * Hash function for the Mask Generation Function
	 *
	 * @var Crypt_Hash
	 * @access private
	 */
	var $mgfHash;

	/**
	 * Encryption mode
	 *
	 * @var Integer
	 * @access private
	 */
	var $encryptionMode = CRYPT_RSA_ENCRYPTION_OAEP;

	/**
	 * Signature mode
	 *
	 * @var Integer
	 * @access private
	 */
	var $signatureMode = CRYPT_RSA_SIGNATURE_PSS;

	/**
	 * Public Exponent
	 *
	 * @var Mixed
	 * @access private
	 */
	var $publicExponent = false;

	/**
	 * Password
	 *
	 * @var String
	 * @access private
	 */
	var $password = '';

	/**
	 * The constructor
	 *
	 * If you want to make use of the openssl extension, you'll need to set the mode manually, yourself.  The reason
	 * Crypt_RSA doesn't do it is because OpenSSL doesn't fail gracefully.  openssl_pkey_new(), in particular, requires
	 * openssl.cnf be present somewhere and, unfortunately, the only real way to find out is too late.
	 *
	 * @return Crypt_RSA
	 * @access public
	 */
	function Crypt_RSA()
	{
		if ( !defined('CRYPT_RSA_MODE') ) {
			switch (true) {
				//case extension_loaded('openssl') && version_compare(PHP_VERSION, '4.2.0', '>='):
				//    define('CRYPT_RSA_MODE', CRYPT_RSA_MODE_OPENSSL);
				//    break;
				default:
					define('CRYPT_RSA_MODE', CRYPT_RSA_MODE_INTERNAL);
			}
		}

		$this->zero = new Math_BigInteger();
		$this->one = new Math_BigInteger(1);

		$this->hash = new Crypt_Hash('sha1');
		$this->hLen = $this->hash->getLength();
		$this->hashName = 'sha1';
		$this->mgfHash = new Crypt_Hash('sha1');
	}

	/**
	 * Create public / private key pair
	 *
	 * Returns an array with the following three elements:
	 *  - 'privatekey': The private key.
	 *  - 'publickey':  The public key.
	 *  - 'partialkey': A partially computed key (if the execution time exceeded $timeout).
	 *                  Will need to be passed back to Crypt_RSA::createKey() as the third parameter for further processing.
	 *
	 * @access public
	 * @param optional Integer $bits
	 * @param optional Integer $timeout
	 * @param optional Math_BigInteger $p
	 */
	function createKey($bits = 1024, $timeout = false, $primes = array())
	{
		if ( CRYPT_RSA_MODE == CRYPT_RSA_MODE_OPENSSL ) {
			$rsa = openssl_pkey_new(array('private_key_bits' => $bits));
			openssl_pkey_export($rsa, $privatekey);
			$publickey = openssl_pkey_get_details($rsa);
			$publickey = $publickey['key'];

			if ($this->privateKeyFormat != CRYPT_RSA_PRIVATE_FORMAT_PKCS1) {
				$privatekey = call_user_func_array(array($this, '_convertPrivateKey'), array_values($this->_parseKey($privatekey, CRYPT_RSA_PRIVATE_FORMAT_PKCS1)));
				$publickey = call_user_func_array(array($this, '_convertPublicKey'), array_values($this->_parseKey($publickey, CRYPT_RSA_PUBLIC_FORMAT_PKCS1)));
			}

			return array(
                'privatekey' => $privatekey,
                'publickey' => $publickey,
                'partialkey' => false
			);
		}

		static $e;
		if (!isset($e)) {
			if (!defined('CRYPT_RSA_EXPONENT')) {
				// http://en.wikipedia.org/wiki/65537_%28number%29
				define('CRYPT_RSA_EXPONENT', '65537');
			}
			if (!defined('CRYPT_RSA_COMMENT')) {
				define('CRYPT_RSA_COMMENT', 'phpseclib-generated-key');
			}
			// per <http://cseweb.ucsd.edu/~hovav/dist/survey.pdf#page=5>, this number ought not result in primes smaller
			// than 256 bits.
			if (!defined('CRYPT_RSA_SMALLEST_PRIME')) {
				define('CRYPT_RSA_SMALLEST_PRIME', 4096);
			}

			$e = new Math_BigInteger(CRYPT_RSA_EXPONENT);
		}

		extract($this->_generateMinMax($bits));
		$absoluteMin = $min;
		$temp = $bits >> 1;
		if ($temp > CRYPT_RSA_SMALLEST_PRIME) {
			$num_primes = floor($bits / CRYPT_RSA_SMALLEST_PRIME);
			$temp = CRYPT_RSA_SMALLEST_PRIME;
		} else {
			$num_primes = 2;
		}
		extract($this->_generateMinMax($temp + $bits % $temp));
		$finalMax = $max;
		extract($this->_generateMinMax($temp));

		$exponents = $coefficients = array();
		$generator = new Math_BigInteger();
		$generator->setRandomGenerator('crypt_random');

		$n = $this->one->copy();
		$lcm = array(
            'top' => $this->one->copy(),
            'bottom' => false
		);

		$start = time();
		$i0 = count($primes) + 1;

		do {
			for ($i = $i0; $i <= $num_primes; $i++) {
				if ($timeout !== false) {
					$timeout-= time() - $start;
					$start = time();
					if ($timeout <= 0) {
						return array(
                            'privatekey' => '',
                            'publickey'  => '',
                            'partialkey' => $primes
						);
					}
				}
				if ($i == $num_primes) {
					list($min, $temp) = $absoluteMin->divide($n);
					if (!$temp->equals($this->zero)) {
						$min = $min->add($this->one); // ie. ceil()
					}
					$primes[$i] = $generator->randomPrime($min, $finalMax, $timeout);
				} else {
					$primes[$i] = $generator->randomPrime($min, $max, $timeout);
				}

				if ($primes[$i] === false) { // if we've reached the timeout
					return array(
                        'privatekey' => '',
                        'publickey'  => '',
                        'partialkey' => array_slice($primes, 0, $i - 1)
					);
				}

				// the first coefficient is calculated differently from the rest
				// ie. instead of being $primes[1]->modInverse($primes[2]), it's $primes[2]->modInverse($primes[1])
				if ($i > 2) {
					$coefficients[$i] = $n->modInverse($primes[$i]);
				}

				$n = $n->multiply($primes[$i]);

				$temp = $primes[$i]->subtract($this->one);

				// textbook RSA implementations use Euler's totient function instead of the least common multiple.
				// see http://en.wikipedia.org/wiki/Euler%27s_totient_function
				$lcm['top'] = $lcm['top']->multiply($temp);
				$lcm['bottom'] = $lcm['bottom'] === false ? $temp : $lcm['bottom']->gcd($temp);

				$exponents[$i] = $e->modInverse($temp);
			}

			list($lcm) = $lcm['top']->divide($lcm['bottom']);
			$gcd = $lcm->gcd($e);
			$i0 = 1;
		} while (!$gcd->equals($this->one));

		$d = $e->modInverse($lcm);

		$coefficients[2] = $primes[2]->modInverse($primes[1]);

		// from <http://tools.ietf.org/html/rfc3447#appendix-A.1.2>:
		// RSAPrivateKey ::= SEQUENCE {
		//     version           Version,
			//     modulus           INTEGER,  -- n
			//     publicExponent    INTEGER,  -- e
			//     privateExponent   INTEGER,  -- d
			//     prime1            INTEGER,  -- p
			//     prime2            INTEGER,  -- q
			//     exponent1         INTEGER,  -- d mod (p-1)
			//     exponent2         INTEGER,  -- d mod (q-1)
			//     coefficient       INTEGER,  -- (inverse of q) mod p
			//     otherPrimeInfos   OtherPrimeInfos OPTIONAL
			// }

			return array(
            'privatekey' => $this->_convertPrivateKey($n, $e, $d, $primes, $exponents, $coefficients),
            'publickey'  => $this->_convertPublicKey($n, $e),
            'partialkey' => false
			);
		}

		/**
		 * Convert a private key to the appropriate format.
		 *
		 * @access private
		 * @see setPrivateKeyFormat()
		 * @param String $RSAPrivateKey
		 * @return String
		 */
		function _convertPrivateKey($n, $e, $d, $primes, $exponents, $coefficients)
		{
			$num_primes = count($primes);

			$raw = array(
            'version' => $num_primes == 2 ? chr(0) : chr(1), // two-prime vs. multi
            'modulus' => $n->toBytes(true),
            'publicExponent' => $e->toBytes(true),
            'privateExponent' => $d->toBytes(true),
            'prime1' => $primes[1]->toBytes(true),
            'prime2' => $primes[2]->toBytes(true),
            'exponent1' => $exponents[1]->toBytes(true),
            'exponent2' => $exponents[2]->toBytes(true),
            'coefficient' => $coefficients[2]->toBytes(true)
			);

			// if the format in question does not support multi-prime rsa and multi-prime rsa was used,
			// call _convertPublicKey() instead.
			switch ($this->privateKeyFormat) {
				default: // eg. CRYPT_RSA_PRIVATE_FORMAT_PKCS1
					$components = array();
					foreach ($raw as $name => $value) {
						$components[$name] = pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($value)), $value);
					}

					$RSAPrivateKey = implode('', $components);

					if ($num_primes > 2) {
						$OtherPrimeInfos = '';
						for ($i = 3; $i <= $num_primes; $i++) {
							// OtherPrimeInfos ::= SEQUENCE SIZE(1..MAX) OF OtherPrimeInfo
							//
							// OtherPrimeInfo ::= SEQUENCE {
							//     prime             INTEGER,  -- ri
								//     exponent          INTEGER,  -- di
								//     coefficient       INTEGER   -- ti
								// }
								$OtherPrimeInfo = pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($primes[$i]->toBytes(true))), $primes[$i]->toBytes(true));
								$OtherPrimeInfo.= pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($exponents[$i]->toBytes(true))), $exponents[$i]->toBytes(true));
								$OtherPrimeInfo.= pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($coefficients[$i]->toBytes(true))), $coefficients[$i]->toBytes(true));
								$OtherPrimeInfos.= pack('Ca*a*', CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($OtherPrimeInfo)), $OtherPrimeInfo);
						}
						$RSAPrivateKey.= pack('Ca*a*', CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($OtherPrimeInfos)), $OtherPrimeInfos);
					}

					$RSAPrivateKey = pack('Ca*a*', CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($RSAPrivateKey)), $RSAPrivateKey);

					if (!empty($this->password)) {
						$iv = $this->_random(8);
						$symkey = pack('H*', md5($this->password . $iv)); // symkey is short for symmetric key
						$symkey.= substr(pack('H*', md5($symkey . $this->password . $iv)), 0, 8);
						if (!class_exists('Crypt_TripleDES')) {
							require_once('Crypt/TripleDES.php');
						}
						$des = new Crypt_TripleDES();
						$des->setKey($symkey);
						$des->setIV($iv);
						$iv = strtoupper(bin2hex($iv));
						$RSAPrivateKey = "-----BEGIN RSA PRIVATE KEY-----\r\n" .
                                     "Proc-Type: 4,ENCRYPTED\r\n" .
                                     "DEK-Info: DES-EDE3-CBC,$iv\r\n" .
                                     "\r\n" .
						chunk_split(base64_encode($des->encrypt($RSAPrivateKey))) .
                                     '-----END RSA PRIVATE KEY-----';
					} else {
						$RSAPrivateKey = "-----BEGIN RSA PRIVATE KEY-----\r\n" .
						chunk_split(base64_encode($RSAPrivateKey)) .
                                     '-----END RSA PRIVATE KEY-----';
					}

					return $RSAPrivateKey;
			}
		}

		/**
		 * Convert a public key to the appropriate format
		 *
		 * @access private
		 * @see setPublicKeyFormat()
		 * @param String $RSAPrivateKey
		 * @return String
		 */
		function _convertPublicKey($n, $e)
		{
			$modulus = $n->toBytes(true);
			$publicExponent = $e->toBytes(true);

			switch ($this->publicKeyFormat) {
				case CRYPT_RSA_PUBLIC_FORMAT_RAW:
					return array('e' => $e->copy(), 'n' => $n->copy());
				case CRYPT_RSA_PUBLIC_FORMAT_OPENSSH:
					// from <http://tools.ietf.org/html/rfc4253#page-15>:
					// string    "ssh-rsa"
					// mpint     e
					// mpint     n
					$RSAPublicKey = pack('Na*Na*Na*', strlen('ssh-rsa'), 'ssh-rsa', strlen($publicExponent), $publicExponent, strlen($modulus), $modulus);
					$RSAPublicKey = 'ssh-rsa ' . base64_encode($RSAPublicKey) . ' ' . CRYPT_RSA_COMMENT;

					return $RSAPublicKey;
				default: // eg. CRYPT_RSA_PUBLIC_FORMAT_PKCS1
					// from <http://tools.ietf.org/html/rfc3447#appendix-A.1.1>:
					// RSAPublicKey ::= SEQUENCE {
					//     modulus           INTEGER,  -- n
					//     publicExponent    INTEGER   -- e
					// }
					$components = array(
                    'modulus' => pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($modulus)), $modulus),
                    'publicExponent' => pack('Ca*a*', CRYPT_RSA_ASN1_INTEGER, $this->_encodeLength(strlen($publicExponent)), $publicExponent)
					);

					$RSAPublicKey = pack('Ca*a*a*',
					CRYPT_RSA_ASN1_SEQUENCE, $this->_encodeLength(strlen($components['modulus']) + strlen($components['publicExponent'])),
					$components['modulus'], $components['publicExponent']
					);

					$RSAPublicKey = "-----BEGIN PUBLIC KEY-----\r\n" .
					chunk_split(base64_encode($RSAPublicKey)) .
                                 '-----END PUBLIC KEY-----';

					return $RSAPublicKey;
		}
}

/**
 * Break a public or private key down into its constituant components
 *
 * @access private
 * @see _convertPublicKey()
 * @see _convertPrivateKey()
 * @param String $key
 * @param Integer $type
 * @return Array
 */
function _parseKey($key, $type)
{
	switch ($type) {
		case CRYPT_RSA_PUBLIC_FORMAT_RAW:
			if (!is_array($key)) {
				return false;
			}
			$components = array();
			switch (true) {
				case isset($key['e']):
					$components['publicExponent'] = $key['e']->copy();
					break;
				case isset($key['exponent']):
					$components['publicExponent'] = $key['exponent']->copy();
					break;
				case isset($key['publicExponent']):
					$components['publicExponent'] = $key['publicExponent']->copy();
					break;
				case isset($key[0]):
					$components['publicExponent'] = $key[0]->copy();
			}
			switch (true) {
				case isset($key['n']):
					$components['modulus'] = $key['n']->copy();
					break;
				case isset($key['modulo']):
					$components['modulus'] = $key['modulo']->copy();
					break;
				case isset($key['modulus']):
					$components['modulus'] = $key['modulus']->copy();
					break;
				case isset($key[1]):
					$components['modulus'] = $key[1]->copy();
			}
			return $components;
		case CRYPT_RSA_PRIVATE_FORMAT_PKCS1:
		case CRYPT_RSA_PUBLIC_FORMAT_PKCS1:
			/* Although PKCS#1 proposes a format that public and private keys can use, encrypting them is
			 "outside the scope" of PKCS#1.  PKCS#1 then refers you to PKCS#12 and PKCS#15 if you're wanting to
			 protect private keys, however, that's not what OpenSSL* does.  OpenSSL protects private keys by adding
			 two new "fields" to the key - DEK-Info and Proc-Type.  These fields are discussed here:

			 http://tools.ietf.org/html/rfc1421#section-4.6.1.1
			 http://tools.ietf.org/html/rfc1421#section-4.6.1.3

			 DES-EDE3-CBC as an algorithm, however, is not discussed anywhere, near as I can tell.
			 DES-CBC and DES-EDE are discussed in RFC1423, however, DES-EDE3-CBC isn't, nor is its key derivation
			 function.  As is, the definitive authority on this encoding scheme isn't the IETF but rather OpenSSL's
			 own implementation.  ie. the implementation *is* the standard and any bugs that may exist in that
			 implementation are part of the standard, as well.

			 * OpenSSL is the de facto standard.  It's utilized by OpenSSH and other projects */
			if (preg_match('#DEK-Info: DES-EDE3-CBC,(.+)#', $key, $matches)) {
				$iv = pack('H*', trim($matches[1]));
				$symkey = pack('H*', md5($this->password . $iv)); // symkey is short for symmetric key
				$symkey.= substr(pack('H*', md5($symkey . $this->password . $iv)), 0, 8);
				$ciphertext = base64_decode(preg_replace('#.+(\r|\n|\r\n)\1|[\r\n]|-.+-#s', '', $key));
				if ($ciphertext === false) {
					return false;
				}
				if (!class_exists('Crypt_TripleDES')) {
					require_once('Crypt/TripleDES.php');
				}
				$des = new Crypt_TripleDES();
				$des->setKey($symkey);
				$des->setIV($iv);
				$key = $des->decrypt($ciphertext);
			} else {
				$key = base64_decode(preg_replace('#-.+-|[\r\n]#', '', $key));
				if ($key === false) {
					return false;
				}
			}

			$private = false;
			$components = array();

			$this->_string_shift($key); // skip over CRYPT_RSA_ASN1_SEQUENCE
			$this->_decodeLength($key); // skip over the length of the above sequence
			$this->_string_shift($key); // skip over CRYPT_RSA_ASN1_INTEGER
			$length = $this->_decodeLength($key);
			$temp = $this->_string_shift($key, $length);
			if (strlen($temp) != 1 || ord($temp) > 2) {
				$components['modulus'] = new Math_BigInteger($temp, -256);
				$this->_string_shift($key); // skip over CRYPT_RSA_ASN1_INTEGER
				$length = $this->_decodeLength($key);
				$components[$type == CRYPT_RSA_PUBLIC_FORMAT_PKCS1 ? 'publicExponent' : 'privateExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);

				return $components;
			}
			$this->_string_shift($key); // skip over CRYPT_RSA_ASN1_INTEGER
			$length = $this->_decodeLength($key);
			$components['modulus'] = new Math_BigInteger($this->_string_shift($key, $length), -256);
			$this->_string_shift($key);
			$length = $this->_decodeLength($key);
			$components['publicExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);
			$this->_string_shift($key);
			$length = $this->_decodeLength($key);
			$components['privateExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);
			$this->_string_shift($key);
			$length = $this->_decodeLength($key);
			$components['primes'] = array(1 => new Math_BigInteger($this->_string_shift($key, $length), -256));
			$this->_string_shift($key);
			$length = $this->_decodeLength($key);
			$components['primes'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);
			$this->_string_shift($key);
			$length = $this->_decodeLength($key);
			$components['exponents'] = array(1 => new Math_BigInteger($this->_string_shift($key, $length), -256));
			$this->_string_shift($key);
			$length = $this->_decodeLength($key);
			$components['exponents'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);
			$this->_string_shift($key);
			$length = $this->_decodeLength($key);
			$components['coefficients'] = array(2 => new Math_BigInteger($this->_string_shift($key, $length), -256));
			if (!empty($key)) {
				$key = substr($key, 1); // skip over CRYPT_RSA_ASN1_SEQUENCE
				$this->_decodeLength($key);
				while (!empty($key)) {
					$key = substr($key, 1); // skip over CRYPT_RSA_ASN1_SEQUENCE
					$this->_decodeLength($key);
					$key = substr($key, 1);
					$length = $this->_decodeLength($key);
					$components['primes'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);
					$this->_string_shift($key);
					$length = $this->_decodeLength($key);
					$components['exponents'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);
					$this->_string_shift($key);
					$length = $this->_decodeLength($key);
					$components['coefficients'][] = new Math_BigInteger($this->_string_shift($key, $length), -256);
				}
			}

			return $components;
		case CRYPT_RSA_PUBLIC_FORMAT_OPENSSH:
			$key = base64_decode(preg_replace('#^ssh-rsa | .+$#', '', $key));
			if ($key === false) {
				return false;
			}

			$components = array();
			extract(unpack('Nlength', $this->_string_shift($key, 4)));
			$components['modulus'] = new Math_BigInteger($this->_string_shift($key, $length), -256);
			extract(unpack('Nlength', $this->_string_shift($key, 4)));
			$components['publicExponent'] = new Math_BigInteger($this->_string_shift($key, $length), -256);

			return $components;
	}
}

/**
 * Loads a public or private key
 *
 * @access public
 * @param String $key
 * @param Integer $type optional
 */
function loadKey($key, $type = CRYPT_RSA_PRIVATE_FORMAT_PKCS1)
{
	$components = $this->_parseKey($key, $type);
	$this->modulus = $components['modulus'];
	$this->k = strlen($this->modulus->toBytes());
	$this->exponent = isset($components['privateExponent']) ? $components['privateExponent'] : $components['publicExponent'];
	if (isset($components['primes'])) {
		$this->primes = $components['primes'];
		$this->exponents = $components['exponents'];
		$this->coefficients = $components['coefficients'];
		$this->publicExponent = $components['publicExponent'];
	} else {
		$this->primes = array();
		$this->exponents = array();
		$this->coefficients = array();
		$this->publicExponent = false;
	}
}

/**
 * Sets the password
 *
 * Private keys can be encrypted with a password.  To unset the password, pass in the empty string or false.
 * Or rather, pass in $password such that empty($password) is true.
 *
 * @see createKey()
 * @see loadKey()
 * @access public
 * @param String $password
 */
function setPassword($password)
{
	$this->password = $password;
}

/**
 * Defines the public key
 *
 * Some private key formats define the public exponent and some don't.  Those that don't define it are problematic when
 * used in certain contexts.  For example, in SSH-2, RSA authentication works by sending the public key along with a
 * message signed by the private key to the server.  The SSH-2 server looks the public key up in an index of public keys
 * and if it's present then proceeds to verify the signature.  Problem is, if your private key doesn't include the public
 * exponent this won't work unless you manually add the public exponent.
 *
 * Do note that when a new key is loaded the index will be cleared.
 *
 * Returns true on success, false on failure
 *
 * @see getPublicKey()
 * @access public
 * @param String $key
 * @param Integer $type optional
 * @return Boolean
 */
function setPublicKey($key, $type = CRYPT_RSA_PUBLIC_FORMAT_PKCS1)
{
	$components = $this->_parseKey($key, $type);
	if (!$this->modulus->equals($components['modulus'])) {
		return false;
	}
	$this->publicExponent = $components['publicExponent'];
}

/**
 * Returns the public key
 *
 * The public key is only returned under two circumstances - if the private key had the public key embedded within it
 * or if the public key was set via setPublicKey().  If the currently loaded key is supposed to be the public key this
 * function won't return it since this library, for the most part, doesn't distinguish between public and private keys.
 *
 * @see getPublicKey()
 * @access public
 * @param String $key
 * @param Integer $type optional
 */
function getPublicKey($type = CRYPT_RSA_PUBLIC_FORMAT_PKCS1)
{
	$oldFormat = $this->publicKeyFormat;
	$this->publicKeyFormat = $type;
	$temp = $this->_convertPublicKey($this->modulus, $this->publicExponent);
	$this->publicKeyFormat = $oldFormat;
	return $temp;
}

/**
 * Generates the smallest and largest numbers requiring $bits bits
 *
 * @access private
 * @param Integer $bits
 * @return Array
 */
function _generateMinMax($bits)
{
	$bytes = $bits >> 3;
	$min = str_repeat(chr(0), $bytes);
	$max = str_repeat(chr(0xFF), $bytes);
	$msb = $num_bits & 7;
	if ($msb) {
		$min = chr(1 << ($msb - 1)) . $min;
		$max = chr((1 << $msb) - 1) . $max;
	} else {
		$min[0] = chr(0x80);
	}

	return array(
            'min' => new Math_BigInteger($min, 256),
            'max' => new Math_BigInteger($max, 256)
	);
}

/**
 * DER-decode the length
 *
 * DER supports lengths up to (2**8)**127, however, we'll only support lengths up to (2**8)**4.  See
 * {@link http://itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf#p=13 X.690 § 8.1.3} for more information.
 *
 * @access private
 * @param String $string
 * @return Integer
 */
function _decodeLength(&$string)
{
	$length = ord($this->_string_shift($string));
	if ( $length & 0x80 ) { // definite length, long form
		$length&= 0x7F;
		$temp = $this->_string_shift($string, $length);
		$start+= $length;
		list(, $length) = unpack('N', substr(str_pad($temp, 4, chr(0), STR_PAD_LEFT), -4));
	}
	return $length;
}

/**
 * DER-encode the length
 *
 * DER supports lengths up to (2**8)**127, however, we'll only support lengths up to (2**8)**4.  See
 * {@link http://itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf#p=13 X.690 § 8.1.3} for more information.
 *
 * @access private
 * @param Integer $length
 * @return String
 */
function _encodeLength($length)
{
	if ($length <= 0x7F) {
		return chr($length);
	}

	$temp = ltrim(pack('N', $length), chr(0));
	return pack('Ca*', 0x80 | strlen($temp), $temp);
}

/**
 * String Shift
 *
 * Inspired by array_shift
 *
 * @param String $string
 * @param optional Integer $index
 * @return String
 * @access private
 */
function _string_shift(&$string, $index = 1)
{
	$substr = substr($string, 0, $index);
	$string = substr($string, $index);
	return $substr;
}

/**
 * Determines the private key format
 *
 * @see createKey()
 * @access public
 * @param Integer $format
 */
function setPrivateKeyFormat($format)
{
	$this->privateKeyFormat = $format;
}

/**
 * Determines the public key format
 *
 * @see createKey()
 * @access public
 * @param Integer $format
 */
function setPublicKeyFormat($format)
{
	$this->publicKeyFormat = $format;
}

/**
 * Determines which hashing function should be used
 *
 * Used with signature production / verification and (if the encryption mode is CRYPT_RSA_ENCRYPTION_OAEP) encryption and
 * decryption.  If $hash isn't supported, sha1 is used.
 *
 * @access public
 * @param String $hash
 */
function setHash($hash)
{
	// Crypt_Hash supports algorithms that PKCS#1 doesn't support.  md5-96 and sha1-96, for example.
	switch ($hash) {
		case 'md2':
		case 'md5':
		case 'sha1':
		case 'sha256':
		case 'sha384':
		case 'sha512':
			$this->hash = new Crypt_Hash($hash);
			$this->hLen = $this->hash->getLength();
			$this->hashName = $hash;
			break;
		default:
			$this->hash = new Crypt_Hash('sha1');
			$this->hLen = $this->hash->getLength();
			$this->hashName = 'sha1';
	}
}

/**
 * Determines which hashing function should be used for the mask generation function
 *
 * The mask generation function is used by CRYPT_RSA_ENCRYPTION_OAEP and CRYPT_RSA_SIGNATURE_PSS and although it's
 * best if Hash and MGFHash are set to the same thing this is not a requirement.
 *
 * @access public
 * @param String $hash
 */
function setMGFHash($hash)
{
	// Crypt_Hash supports algorithms that PKCS#1 doesn't support.  md5-96 and sha1-96, for example.
	switch ($hash) {
		case 'md2':
		case 'md5':
		case 'sha1':
		case 'sha256':
		case 'sha384':
		case 'sha512':
			$this->mgfHash = new Crypt_Hash($hash);
			break;
		default:
			$this->mgfHash = new Crypt_Hash('sha1');
	}
}

/**
 * Determines the salt length
 *
 * To quote from {@link http://tools.ietf.org/html/rfc3447#page-38 RFC3447#page-38}:
 *
 *    Typical salt lengths in octets are hLen (the length of the output
 *    of the hash function Hash) and 0.
 *
 * @access public
 * @param Integer $format
 */
function setSaltLength($sLen)
{
	$this->sLen = $sLen;
}

/**
 * Generates a random string x bytes long
 *
 * @access public
 * @param Integer $bytes
 * @param optional Integer $nonzero
 * @return String
 */
function _random($bytes, $nonzero = false)
{
	$temp = '';
	if ($nonzero) {
		for ($i = 0; $i < $bytes; $i++) {
			$temp.= chr(crypt_random(1, 255));
		}
	} else {
		$ints = ($bytes + 1) >> 2;
		for ($i = 0; $i < $ints; $i++) {
			$temp.= pack('N', crypt_random());
		}
		$temp = substr($temp, 0, $bytes);
	}
	return $temp;
}

/**
 * Integer-to-Octet-String primitive
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-4.1 RFC3447#section-4.1}.
 *
 * @access private
 * @param Math_BigInteger $x
 * @param Integer $xLen
 * @return String
 */
function _i2osp($x, $xLen)
{
	$x = $x->toBytes();
	if (strlen($x) > $xLen) {
		user_error('Integer too large', E_USER_NOTICE);
		return false;
	}
	return str_pad($x, $xLen, chr(0), STR_PAD_LEFT);
}

/**
 * Octet-String-to-Integer primitive
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-4.2 RFC3447#section-4.2}.
 *
 * @access private
 * @param String $x
 * @return Math_BigInteger
 */
function _os2ip($x)
{
	return new Math_BigInteger($x, 256);
}

/**
 * Exponentiate with or without Chinese Remainder Theorem
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-5.1.1 RFC3447#section-5.1.2}.
 *
 * @access private
 * @param Math_BigInteger $x
 * @return Math_BigInteger
 */
function _exponentiate($x)
{
	if (empty($this->primes) || empty($this->coefficients) || empty($this->exponents)) {
		return $x->modPow($this->exponent, $this->modulus);
	}

	$num_primes = count($this->primes);
	$m_i = array(
	1 => $x->modPow($this->exponents[1], $this->primes[1]),
	2 => $x->modPow($this->exponents[2], $this->primes[2])
	);
	$h = $m_i[1]->subtract($m_i[2]);
	$h = $h->multiply($this->coefficients[2]);
	list(, $h) = $h->divide($this->primes[1]);
	$m = $m_i[2]->add($h->multiply($this->primes[2]));

	$r = $this->primes[1];
	for ($i = 3; $i <= $num_primes; $i++) {
		$m_i = $x->modPow($this->exponents[$i], $this->primes[$i]);

		$r = $r->multiply($this->primes[$i - 1]);

		$h = $m_i->subtract($m);
		$h = $h->multiply($this->coefficients[$i]);
		list(, $h) = $h->divide($this->primes[$i]);

		$m = $m->add($r->multiply($h));
	}

	return $m;
}

/**
 * RSAEP
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-5.1.1 RFC3447#section-5.1.1}.
 *
 * @access private
 * @param Math_BigInteger $m
 * @return Math_BigInteger
 */
function _rsaep($m)
{
	if ($m->compare($this->zero) < 0 || $m->compare($this->modulus) > 0) {
		user_error('Message representative out of range', E_USER_NOTICE);
		return false;
	}
	return $this->_exponentiate($m);
}

/**
 * RSADP
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-5.1.2 RFC3447#section-5.1.2}.
 *
 * @access private
 * @param Math_BigInteger $c
 * @return Math_BigInteger
 */
function _rsadp($c)
{
	if ($c->compare($this->zero) < 0 || $c->compare($this->modulus) > 0) {
		user_error('Ciphertext representative out of range', E_USER_NOTICE);
		return false;
	}
	return $this->_exponentiate($c);
}

/**
 * RSASP1
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-5.2.1 RFC3447#section-5.2.1}.
 *
 * @access private
 * @param Math_BigInteger $m
 * @return Math_BigInteger
 */
function _rsasp1($m)
{
	if ($m->compare($this->zero) < 0 || $m->compare($this->modulus) > 0) {
		user_error('Message representative out of range', E_USER_NOTICE);
		return false;
	}
	return $this->_exponentiate($m);
}

/**
 * RSAVP1
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-5.2.2 RFC3447#section-5.2.2}.
 *
 * @access private
 * @param Math_BigInteger $s
 * @return Math_BigInteger
 */
function _rsavp1($s)
{
	if ($s->compare($this->zero) < 0 || $s->compare($this->modulus) > 0) {
		user_error('Signature representative out of range', E_USER_NOTICE);
		return false;
	}
	return $this->_exponentiate($s);
}

/**
 * MGF1
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-B.2.1 RFC3447#section-B.2.1}.
 *
 * @access private
 * @param String $mgfSeed
 * @param Integer $mgfLen
 * @return String
 */
function _mgf1($mgfSeed, $maskLen)
{
	// if $maskLen would yield strings larger than 4GB, PKCS#1 suggests a "Mask too long" error be output.

	$t = '';
	$count = ceil($maskLen / $this->hLen);
	for ($i = 0; $i < $count; $i++) {
		$c = pack('N', $i);
		$t.= $this->mgfHash->hash($mgfSeed . $c);
	}

	return substr($t, 0, $maskLen);
}

/**
 * RSAES-OAEP-ENCRYPT
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-7.1.1 RFC3447#section-7.1.1} and
 * {http://en.wikipedia.org/wiki/Optimal_Asymmetric_Encryption_Padding OAES}.
 *
 * @access private
 * @param String $m
 * @param String $l
 * @return String
 */
function _rsaes_oaep_encrypt($m, $l = '')
{
	$mLen = strlen($m);

	// Length checking

	// if $l is larger than two million terrabytes and you're using sha1, PKCS#1 suggests a "Label too long" error
	// be output.

	if ($mLen > $this->k - 2 * $this->hLen - 2) {
		user_error('Message too long', E_USER_NOTICE);
		return false;
	}

	// EME-OAEP encoding

	$lHash = $this->hash->hash($l);
	$ps = str_repeat(chr(0), $this->k - $mLen - 2 * $this->hLen - 2);
	$db = $lHash . $ps . chr(1) . $m;
	$seed = $this->_random($this->hLen);
	$dbMask = $this->_mgf1($seed, $this->k - $this->hLen - 1);
	$maskedDB = $db ^ $dbMask;
	$seedMask = $this->_mgf1($maskedDB, $this->hLen);
	$maskedSeed = $seed ^ $seedMask;
	$em = chr(0) . $maskedSeed . $maskedDB;

	// RSA encryption

	$m = $this->_os2ip($em);
	$c = $this->_rsaep($m);
	$c = $this->_i2osp($c, $this->k);

	// Output the ciphertext C

	return $c;
}

/**
 * RSAES-OAEP-DECRYPT
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-7.1.2 RFC3447#section-7.1.2}.  The fact that the error
 * messages aren't distinguishable from one another hinders debugging, but, to quote from RFC3447#section-7.1.2:
 *
 *    Note.  Care must be taken to ensure that an opponent cannot
 *    distinguish the different error conditions in Step 3.g, whether by
 *    error message or timing, or, more generally, learn partial
 *    information about the encoded message EM.  Otherwise an opponent may
 *    be able to obtain useful information about the decryption of the
 *    ciphertext C, leading to a chosen-ciphertext attack such as the one
 *    observed by Manger [36].
 *
 * As for $l...  to quote from {@link http://tools.ietf.org/html/rfc3447#page-17 RFC3447#page-17}:
 *
 *    Both the encryption and the decryption operations of RSAES-OAEP take
 *    the value of a label L as input.  In this version of PKCS #1, L is
 *    the empty string; other uses of the label are outside the scope of
 *    this document.
 *
 * @access private
 * @param String $c
 * @param String $l
 * @return String
 */
function _rsaes_oaep_decrypt($c, $l = '')
{
	// Length checking

	// if $l is larger than two million terrabytes and you're using sha1, PKCS#1 suggests a "Label too long" error
	// be output.

	if (strlen($c) != $this->k || $this->k < 2 * $this->hLen + 2) {
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}

	// RSA decryption

	$c = $this->_os2ip($c);
	$m = $this->_rsadp($c);
	if ($m === false) {
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}
	$em = $this->_i2osp($m, $this->k);

	// EME-OAEP decoding

	$lHash = $this->hash->hash($l);
	$y = ord($em[0]);
	$maskedSeed = substr($em, 1, $this->hLen);
	$maskedDB = substr($em, $this->hLen + 1);
	$seedMask = $this->_mgf1($maskedDB, $this->hLen);
	$seed = $maskedSeed ^ $seedMask;
	$dbMask = $this->_mgf1($seed, $this->k - $this->hLen - 1);
	$db = $maskedDB ^ $dbMask;
	$lHash2 = substr($db, 0, $this->hLen);
	$m = substr($db, $this->hLen);
	if ($lHash != $lHash2) {
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}
	$m = ltrim($m, chr(0));
	if (ord($m[0]) != 1) {
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}

	// Output the message M

	return substr($m, 1);
}

/**
 * RSAES-PKCS1-V1_5-ENCRYPT
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-7.2.1 RFC3447#section-7.2.1}.
 *
 * @access private
 * @param String $m
 * @return String
 */
function _rsaes_pkcs1_v1_5_encrypt($m)
{
	$mLen = strlen($m);

	// Length checking

	if ($mLen > $this->k - 11) {
		user_error('Message too long', E_USER_NOTICE);
		return false;
	}

	// EME-PKCS1-v1_5 encoding

	$ps = $this->_random($this->k - $mLen - 3, true);
	$em = chr(0) . chr(2) . $ps . chr(0) . $m;

	// RSA encryption
	$m = $this->_os2ip($em);
	$c = $this->_rsaep($m);
	$c = $this->_i2osp($c, $this->k);

	// Output the ciphertext C

	return $c;
}

/**
 * RSAES-PKCS1-V1_5-DECRYPT
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-7.2.2 RFC3447#section-7.2.2}.
 *
 * @access private
 * @param String $c
 * @return String
 */
function _rsaes_pkcs1_v1_5_decrypt($c)
{
	// Length checking

	if (strlen($c) != $this->k) { // or if k < 11
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}

	// RSA decryption

	$c = $this->_os2ip($c);
	$m = $this->_rsadp($c);
	if ($m === false) {
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}
	$em = $this->_i2osp($m, $this->k);

	// EME-PKCS1-v1_5 decoding

	if (ord($em[0]) != 0 || ord($em[1]) != 2) {
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}

	$ps = substr($em, 2, strpos($em, chr(0), 2) - 2);
	$m = substr($em, strlen($ps) + 3);

	if (strlen($ps) < 8) {
		user_error('Decryption error', E_USER_NOTICE);
		return false;
	}

	// Output M

	return $m;
}

/**
 * EMSA-PSS-ENCODE
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-9.1.1 RFC3447#section-9.1.1}.
 *
 * @access private
 * @param String $m
 * @param Integer $emBits
 */
function _emsa_pss_encode($m, $emBits)
{
	// if $m is larger than two million terrabytes and you're using sha1, PKCS#1 suggests a "Label too long" error
	// be output.

	$emLen = ($emBits + 1) >> 3; // ie. ceil($emBits / 8)
	$sLen = $this->sLen == false ? $this->hLen : $this->sLen;

	$mHash = $this->hash->hash($m);
	if ($emLen < $this->hLen + $sLen + 2) {
		user_error('Encoding error', E_USER_NOTICE);
		return false;
	}

	$salt = $this->_random($sLen);
	$m2 = "\0\0\0\0\0\0\0\0" . $mHash . $salt;
	$h = $this->hash->hash($m2);
	$ps = str_repeat(chr(0), $emLen - $sLen - $this->hLen - 2);
	$db = $ps . chr(1) . $salt;
	$dbMask = $this->_mgf1($h, $emLen - $this->hLen - 1);
	$maskedDB = $db ^ $dbMask;
	$maskedDB[0] = ~chr(0xFF << ($emBits & 7)) & $maskedDB[0];
	$em = $maskedDB . $h . chr(0xBC);

	return $em;
}

/**
 * EMSA-PSS-VERIFY
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-9.1.2 RFC3447#section-9.1.2}.
 *
 * @access private
 * @param String $m
 * @param String $em
 * @param Integer $emBits
 * @return String
 */
function _emsa_pss_verify($m, $em, $emBits)
{
	// if $m is larger than two million terrabytes and you're using sha1, PKCS#1 suggests a "Label too long" error
	// be output.

	$emLen = ($emBits + 1) >> 3; // ie. ceil($emBits / 8);
	$sLen = $this->sLen == false ? $this->hLen : $this->sLen;

	$mHash = $this->hash->hash($m);
	if ($emLen < $this->hLen + $sLen + 2) {
		return false;
	}

	if ($em[strlen($em) - 1] != chr(0xBC)) {
		return false;
	}

	$maskedDB = substr($em, 0, $em - $this->hLen - 1);
	$h = substr($em, $em - $this->hLen - 1, $this->hLen);
	$temp = chr(0xFF << ($emBits & 7));
	if ((~$maskedDB[0] & $temp) != $temp) {
		return false;
	}
	$dbMask = $this->_mgf1($h, $emLen - $this->hLen - 1);
	$db = $maskedDB ^ $dbMask;
	$db[0] = ~chr(0xFF << ($emBits & 7)) & $db[0];
	$temp = $emLen - $this->hLen - $sLen - 2;
	if (substr($db, 0, $temp) != str_repeat(chr(0), $temp) || ord($db[$temp]) != 1) {
		return false;
	}
	$salt = substr($db, $temp + 1); // should be $sLen long
	$m2 = "\0\0\0\0\0\0\0\0" . $mHash . $salt;
	$h2 = $this->hash->hash($m2);
	return $h == $h2;
}

/**
 * RSASSA-PSS-SIGN
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-8.1.1 RFC3447#section-8.1.1}.
 *
 * @access private
 * @param String $m
 * @return String
 */
function _rsassa_pss_sign($m)
{
	// EMSA-PSS encoding

	$em = $this->_emsa_pss_encode($m, 8 * $this->k - 1);

	// RSA signature

	$m = $this->_os2ip($em);
	$s = $this->_rsasp1($m);
	$s = $this->_i2osp($s, $this->k);

	// Output the signature S

	return $s;
}

/**
 * RSASSA-PSS-VERIFY
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-8.1.2 RFC3447#section-8.1.2}.
 *
 * @access private
 * @param String $m
 * @param String $s
 * @return String
 */
function _rsassa_pss_verify($m, $s)
{
	// Length checking

	if (strlen($s) != $this->k) {
		user_error('Invalid signature', E_USER_NOTICE);
		return false;
	}

	// RSA verification

	$modBits = 8 * $this->k;

	$s2 = $this->_os2ip($s);
	$m2 = $this->_rsavp1($s2);
	if ($m2 === false) {
		user_error('Invalid signature', E_USER_NOTICE);
		return false;
	}
	$em = $this->_i2osp($m2, $modBits >> 3);
	if ($em === false) {
		user_error('Invalid signature', E_USER_NOTICE);
		return false;
	}

	// EMSA-PSS verification

	return $this->_emsa_pss_verify($m, $em, $modBits - 1);
}

/**
 * EMSA-PKCS1-V1_5-ENCODE
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-9.2 RFC3447#section-9.2}.
 *
 * @access private
 * @param String $m
 * @param Integer $emLen
 * @return String
 */
function _emsa_pkcs1_v1_5_encode($m, $emLen)
{
	$h = $this->hash->hash($m);
	if ($h === false) {
		return false;
	}

	// see http://tools.ietf.org/html/rfc3447#page-43
	switch ($this->hashName) {
		case 'md2':
			$t = pack('H*', '3020300c06082a864886f70d020205000410');
			break;
		case 'md5':
			$t = pack('H*', '3020300c06082a864886f70d020505000410');
			break;
		case 'sha1':
			$t = pack('H*', '3021300906052b0e03021a05000414');
			break;
		case 'sha256':
			$t = pack('H*', '3031300d060960864801650304020105000420');
			break;
		case 'sha384':
			$t = pack('H*', '3041300d060960864801650304020205000430');
			break;
		case 'sha512':
			$t = pack('H*', '3051300d060960864801650304020305000440');
	}
	$t.= $h;
	$tLen = strlen($t);

	if ($emLen < $tLen + 11) {
		user_error('Intended encoded message length too short', E_USER_NOTICE);
		return false;
	}

	$ps = str_repeat(chr(0xFF), $emLen - $tLen - 3);

	$em = "\0\1$ps\0$t";

	return $em;
}

/**
 * RSASSA-PKCS1-V1_5-SIGN
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-8.2.1 RFC3447#section-8.2.1}.
 *
 * @access private
 * @param String $m
 * @return String
 */
function _rsassa_pkcs1_v1_5_sign($m)
{
	// EMSA-PKCS1-v1_5 encoding

	$em = $this->_emsa_pkcs1_v1_5_encode($m, $this->k);
	if ($em === false) {
		user_error('RSA modulus too short', E_USER_NOTICE);
		return false;
	}

	// RSA signature

	$m = $this->_os2ip($em);
	$s = $this->_rsasp1($m);
	$s = $this->_i2osp($s, $this->k);

	// Output the signature S

	return $s;
}

/**
 * RSASSA-PKCS1-V1_5-VERIFY
 *
 * See {@link http://tools.ietf.org/html/rfc3447#section-8.2.2 RFC3447#section-8.2.2}.
 *
 * @access private
 * @param String $m
 * @return String
 */
function _rsassa_pkcs1_v1_5_verify($m, $s)
{
	// Length checking

	if (strlen($s) != $this->k) {
		user_error('Invalid signature', E_USER_NOTICE);
		return false;
	}

	// RSA verification

	$s = $this->_os2ip($s);
	$m2 = $this->_rsavp1($s);
	if ($m2 === false) {
		user_error('Invalid signature', E_USER_NOTICE);
		return false;
	}
	$em = $this->_i2osp($m2, $this->k);
	if ($em === false) {
		user_error('Invalid signature', E_USER_NOTICE);
		return false;
	}

	// EMSA-PKCS1-v1_5 encoding

	$em2 = $this->_emsa_pkcs1_v1_5_encode($m, $this->k);
	if ($em2 === false) {
		user_error('RSA modulus too short', E_USER_NOTICE);
		return false;
	}

	// Compare

	return $em == $em2;
}

/**
 * Set Encryption Mode
 *
 * Valid values include CRYPT_RSA_ENCRYPTION_OAEP and CRYPT_RSA_ENCRYPTION_PKCS1.
 *
 * @access public
 * @param Integer $mode
 */
function setEncryptionMode($mode)
{
	$this->encryptionMode = $mode;
}

/**
 * Set Signature Mode
 *
 * Valid values include CRYPT_RSA_SIGNATURE_PSS and CRYPT_RSA_SIGNATURE_PKCS1
 *
 * @access public
 * @param Integer $mode
 */
function setSignatureMode($mode)
{
	$this->signatureMode = $mode;
}

/**
 * Encryption
 *
 * Both CRYPT_RSA_ENCRYPTION_OAEP and CRYPT_RSA_ENCRYPTION_PKCS1 both place limits on how long $plaintext can be.
 * If $plaintext exceeds those limits it will be broken up so that it does and the resultant ciphertext's will
 * be concatenated together.
 *
 * @see decrypt()
 * @access public
 * @param String $plaintext
 * @return String
 */
function encrypt($plaintext)
{
	switch ($this->encryptionMode) {
		case CRYPT_RSA_ENCRYPTION_PKCS1:
			$plaintext = str_split($plaintext, $this->k - 11);
			$ciphertext = '';
			foreach ($plaintext as $m) {
				$ciphertext.= $this->_rsaes_pkcs1_v1_5_encrypt($m);
			}
			return $ciphertext;
			//case CRYPT_RSA_ENCRYPTION_OAEP:
		default:
			$plaintext = str_split($plaintext, $this->k - 2 * $this->hLen - 2);
			$ciphertext = '';
			foreach ($plaintext as $m) {
				$ciphertext.= $this->_rsaes_oaep_encrypt($m);
			}
			return $ciphertext;
	}
}

/**
 * Decryption
 *
 * @see encrypt()
 * @access public
 * @param String $plaintext
 * @return String
 */
function decrypt($ciphertext)
{
	switch ($this->encryptionMode) {
		case CRYPT_RSA_ENCRYPTION_PKCS1:
			$ciphertext = str_split($ciphertext, $this->k);
			$plaintext = '';
			foreach ($ciphertext as $c) {
				$temp = $this->_rsaes_pkcs1_v1_5_decrypt($c);
				if ($temp === false) {
					return false;
				}
				$plaintext.= $temp;
			}
			return $plaintext;
			//case CRYPT_RSA_ENCRYPTION_OAEP:
		default:
			$ciphertext = str_split($ciphertext, $this->k);
			$plaintext = '';
			foreach ($ciphertext as $c) {
				$temp = $this->_rsaes_oaep_decrypt($c);
				if ($temp === false) {
					return false;
				}
				$plaintext.= $temp;
			}
			return $plaintext;
	}
}

/**
 * Create a signature
 *
 * @see verify()
 * @access public
 * @param String $message
 * @return String
 */
function sign($message)
{
	switch ($this->signatureMode) {
		case CRYPT_RSA_SIGNATURE_PKCS1:
			return $this->_rsassa_pkcs1_v1_5_sign($message);
			//case CRYPT_RSA_SIGNATURE_PSS:
		default:
			return $this->_rsassa_pss_sign($message);
	}
}

/**
 * Verifies a signature
 *
 * @see sign()
 * @access public
 * @param String $message
 * @param String $signature
 * @return Boolean
 */
function verify($message, $signature)
{
	switch ($this->signatureMode) {
		case CRYPT_RSA_SIGNATURE_PKCS1:
			return $this->_rsassa_pkcs1_v1_5_verify($message, $signature);
			//case CRYPT_RSA_SIGNATURE_PSS:
		default:
			return $this->_rsassa_pss_verify($message, $signature);
	}
}
}